Obvladovanje Djangovega sistema dovoljenj: Celovit vodnik po avtorizaciji

Na področju spletnega razvoja je varnost izjemnega pomena. Django, zmogljiv spletni ogrodje v Pythonu, ponuja robusten in prilagodljiv sistem dovoljenj za upravljanje avtorizacije uporabnikov in zaščito virov vaše aplikacije. Ta celovit vodnik se poglobi v zapletenost Djangovega sistema dovoljenj, ponuja praktične primere in najboljše prakse za implementacijo varne in razširljive avtorizacije v vaših Django projektih.

Razumevanje avtentikacije proti avtorizaciji

Preden se poglobimo v posebnosti Djangovega sistema dovoljenj, je ključnega pomena razumeti razliko med avtentikacijo in avtorizacijo:

• Avtentikacija: Preverja identiteto uporabnika. Odgovarja na vprašanje "Kdo si?". To se običajno obravnava z kombinacijami uporabniškega imena/gesla, socialnimi prijavami ali drugimi ponudniki identitet.
• Avtorizacija: Določa, kaj sme avtenticiran uporabnik početi. Odgovarja na vprašanje "Kaj smeš početi?". Tu pride v igro Djangov sistem dovoljenj.

Avtentikacija pride *pred* avtorizacijo. Vedeti morate, kdo je uporabnik, preden lahko določite, do česa sme dostopati ali kaj sme spreminjati.

Djangov vgrajen sistem dovoljenj

Django ponuja vgrajen sistem dovoljenj, ki temelji na modelih, uporabnikih in skupinah. Je enostaven za uporabo za osnovne potrebe avtorizacije, vendar ga je mogoče razširiti in prilagoditi za obravnavo bolj kompleksnih scenarijev.

Dovoljenja modelov

Django samodejno ustvari privzeta dovoljenja za vsak model, kar vam omogoča nadzor, kdo lahko ustvarja, bere, posodablja in briše instance tega modela. Ta dovoljenja so:

• add_[ime_modela]: Omogoča ustvarjanje novih instanc modela.
• change_[ime_modela]: Omogoča posodabljanje obstoječih instanc modela.
• delete_[ime_modela]: Omogoča brisanje instanc modela.
• view_[ime_modela]: Omogoča ogled instanc modela (Django 3.1+).

Na primer, če imate model z imenom `Article`, bo Django ustvaril naslednja dovoljenja:

• `add_article`
• `change_article`
• `delete_article`
• `view_article`

Uporabniki in skupine

Djangov vgrajen sistem avtentikacije ponuja dva temeljna entiteta za upravljanje dovoljenj:

• Uporabniki: Posamezni uporabniški računi znotraj vaše aplikacije.
• Skupine: Zbirke uporabnikov z deljenimi dovoljenji. To je bolj vzdržljiv način za hkratno uporabo dovoljenj za več uporabnikov.

Dovoljenja lahko dodelite neposredno uporabnikom ali, pogosteje, dodelite dovoljenja skupinam in nato uporabnike dodate v te skupine.

Primer: Upravljanje dovoljenj za članke

Recimo, da imate blog aplikacijo z modelom `Article`. Želite dovoliti le določenim uporabnikom ustvarjanje novih člankov, urejanje obstoječih in brisanje člankov. Tukaj je, kako to lahko implementirate z Djangovim vgrajenim sistemom dovoljenj:

1. Ustvarite skupine: Ustvarite skupine, kot sta "Urednik" in "Avtor" v Django admin plošči.
2. Dodelite dovoljenja: Dodelite dovoljenja `add_article`, `change_article` in `delete_article` skupini "Urednik". Skupini "Avtor" dodelite samo dovoljenje `add_article`.
3. Dodajte uporabnike v skupine: Dodajte ustrezne uporabnike v skupini "Urednik" in "Avtor".

Zdaj bodo imeli uporabniki v skupini "Urednik" popoln dostop do upravljanja člankov, medtem ko bodo uporabniki v skupini "Avtor" lahko ustvarjali le nove članke.

Implementacija dovoljenj v pogledih

Ko ste definirali dovoljenja in jih dodelili uporabnikom ali skupinam, morate ta dovoljenja uveljaviti v svojih pogledih. Django ponuja več načinov za to:

Dekorator `permission_required`

Dekorator `@permission_required` je preprost način za omejevanje dostopa do pogleda uporabnikom z določenimi dovoljenji.

            
from django.contrib.auth.decorators import permission_required
from django.shortcuts import render

@permission_required('myapp.add_article')
def create_article(request):
    # Only users with the 'myapp.add_article' permission can access this view
    return render(request, 'myapp/create_article.html')

            

              
                Copy
              
            
          

Če uporabnik brez zahtevanega dovoljenja poskuša dostopati do pogleda, bo preusmerjen na stran za prijavo ali pa bo prejel napako 403 Prepovedano, odvisno od vaših nastavitev.

`LoginRequiredMixin` in `PermissionRequiredMixin` (za poglede na podlagi razredov)

Za poglede na podlagi razredov lahko uporabite `LoginRequiredMixin` in `PermissionRequiredMixin` za uveljavljanje avtentikacije in avtorizacije:

            
from django.contrib.auth.mixins import LoginRequiredMixin, PermissionRequiredMixin
from django.views.generic import CreateView
from .models import Article

class ArticleCreateView(LoginRequiredMixin, PermissionRequiredMixin, CreateView):
    model = Article
    fields = ['title', 'content']
    permission_required = 'myapp.add_article'
    template_name = 'myapp/article_form.html'

            

              
                Copy
              
            
          

Ta primer prikazuje, kako omejiti dostop do `ArticleCreateView` samo avtenticiranim uporabnikom z dovoljenjem `add_article`.

Ročno preverjanje dovoljenj

Dovoljenja lahko preverite tudi ročno znotraj svojih pogledov z uporabo metode `has_perm()` na uporabniškem objektu:

            
from django.shortcuts import render, redirect


def update_article(request, article_id):
    article = Article.objects.get(pk=article_id)

    if request.user.has_perm('myapp.change_article', article):
        # User has permission to update the article
        # Implement update logic here
        return render(request, 'myapp/update_article.html', {'article': article})
    else:
        # User does not have permission
        return render(request, 'myapp/permission_denied.html')

            

              
                Copy
              
            
          

V tem primeru preverjamo, ali ima uporabnik dovoljenje `change_article` za določeno instanco `article`. To vam omogoča implementacijo dovoljenj na ravni objekta, kjer so dovoljenja dodeljena na podlagi specifičnega objekta, do katerega se dostopa.

Dovoljenja po meri

Djangova vgrajena dovoljenja so pogosto zadostna za osnovne potrebe avtorizacije. Vendar boste v bolj kompleksnih aplikacijah morda morali definirati dovoljenja po meri, da odražajo specifično poslovno logiko ali zahteve nadzora dostopa.

Definiranje dovoljenj po meri v modelih

Dovoljenja po meri lahko definirate znotraj razreda `Meta` vašega modela z uporabo možnosti `permissions`:

            
from django.db import models

class Article(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    author = models.ForeignKey('auth.User', on_delete=models.CASCADE)
    published_date = models.DateTimeField(blank=True, null=True)

    class Meta:
        permissions = [
            ('can_publish_article', 'Can publish article'),
            ('can_comment_article', 'Can comment on article'),
        ]

            

              
                Copy
              
            
          

Ta primer definira dve dovoljenji po meri: `can_publish_article` in `can_comment_article`. Ta dovoljenja bodo samodejno ustvarjena, ko zaženete `python manage.py migrate`.

Uporaba dovoljenj po meri

Ko ste definirali dovoljenja po meri, jih lahko uporabite na enak način kot vgrajena dovoljenja, z uporabo dekoratorja `@permission_required`, `PermissionRequiredMixin` ali metode `has_perm()`.

            
from django.contrib.auth.decorators import permission_required
from django.shortcuts import render

@permission_required('myapp.can_publish_article')
def publish_article(request, article_id):
    # Only users with the 'myapp.can_publish_article' permission can access this view
    article = Article.objects.get(pk=article_id)
    article.published_date = timezone.now()
    article.save()
    return render(request, 'myapp/article_published.html', {'article': article})

            

              
                Copy
              
            
          

Dovoljenja na ravni objekta

Dovoljenja na ravni objekta vam omogočajo nadzor dostopa do določenih instanc modela, namesto da bi dodelili splošna dovoljenja za vse instance. To je bistveno za aplikacije, kjer bi morali uporabniki imeti dostop ali možnost spreminjanja samo virov, ki so v njihovi lasti ali do katerih jim je bil izrecno dodeljen dostop.

Implementacija dovoljenj na ravni objekta

Obstaja več načinov za implementacijo dovoljenj na ravni objekta v Django:

• Ročno preverjanje dovoljenj: Kot je bilo prikazano prej, lahko uporabite metodo `has_perm()` za preverjanje dovoljenj za določeno instanco objekta.
• Uporaba knjižnic tretjih oseb: Knjižnice, kot je `django-guardian`, ponujajo bolj strukturirane in ponovno uporabne načine za upravljanje dovoljenj na ravni objekta.

Primer: Uporaba `django-guardian`

`django-guardian` poenostavlja postopek dodeljevanja in preverjanja dovoljenj na ravni objekta. Tukaj je osnovni primer:

1. Namestite `django-guardian`: `pip install django-guardian`
2. Konfigurirajte `settings.py`: Dodajte `'guardian'` v `INSTALLED_APPS` in konfigurirajte potrebne avtentikacijske zaledne programe.
3. Dodelite dovoljenja: Uporabite funkcijo `assign_perm()` za podelitev dovoljenj uporabnikom ali skupinam za določene objekte.
4. Preverite dovoljenja: Uporabite funkcijo `has_perm()` za preverjanje, ali ima uporabnik določeno dovoljenje za določen objekt.

            
from guardian.shortcuts import assign_perm, get_perms

# Assign the 'change_article' permission to a user for a specific article
assign_perm('change_article', user, article)

# Check if the user has the 'change_article' permission for the article
if user.has_perm('change_article', article):
    # User has permission
    pass

            

              
                Copy
              
            
          

`django-guardian` ponuja tudi `PermissionListMixin` za poglede na podlagi razredov, kar olajša prikaz seznama objektov, do katerih ima uporabnik dovoljenje za dostop.

Dovoljenja Django REST Framework

Če gradite REST API-je z Django REST Framework, boste morali uporabiti njegove razrede dovoljenj za nadzor dostopa do vaših API končnih točk. DRF ponuja več vgrajenih razredov dovoljenj, vključno z:

• `AllowAny`: Omogoča neomejen dostop do API končne točke.
• `IsAuthenticated`: Zahteva, da je uporabnik avtenticiran za dostop do API končne točke.
• `IsAdminUser`: Zahteva, da je uporabnik skrbnik za dostop do API končne točke.
• `IsAuthenticatedOrReadOnly`: Omogoča dostop samo za branje neavtenticiranim uporabnikom, vendar zahteva avtentikacijo za dostop za pisanje.
• `DjangoModelPermissions`: Uporablja Djangova standardna dovoljenja modelov za nadzor dostopa.
• `DjangoObjectPermissions`: Uporablja `django-guardian` za uveljavljanje dovoljenj na ravni objekta.

Uporaba razredov dovoljenj DRF

Razrede dovoljenj za pogled lahko nastavite z uporabo atributa `permission_classes`:

            
from rest_framework import generics
from rest_framework.permissions import IsAuthenticated

class ArticleList(generics.ListCreateAPIView):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer
    permission_classes = [IsAuthenticated]

            

              
                Copy
              
            
          

Ta primer omejuje dostop do API končne točke `ArticleList` samo avtenticiranim uporabnikom.

Dovoljenja DRF po meri

Ustvarite lahko tudi razrede dovoljenj DRF po meri za implementacijo bolj kompleksne logike avtorizacije. Razred dovoljenj po meri mora podedovati iz `rest_framework.permissions.BasePermission` in preglasiti metodi `has_permission()` in/ali `has_object_permission()`.

            
from rest_framework import permissions

class IsAuthorOrReadOnly(permissions.BasePermission):
    """
    Custom permission to only allow authors of an object to edit it.
    """

    def has_object_permission(self, request, view, obj):
        # Read permissions are allowed to any request,
        # so we'll always allow GET, HEAD or OPTIONS requests.
        if request.method in permissions.SAFE_METHODS:
            return True

        # Instance must have an attribute named `author`.
        return obj.author == request.user

            

              
                Copy
              
            
          

Ta primer definira razred dovoljenj po meri, ki omogoča urejanje članka samo avtorju, hkrati pa omogoča dostop za branje vsem.

Najboljše varnostne prakse

Implementacija robustnega sistema dovoljenj je ključnega pomena za zaščito vaše Django aplikacije. Tukaj je nekaj najboljših varnostnih praks, ki jih je treba upoštevati:

• Načelo najmanjše privilegiranosti: Uporabnikom podelite le minimalna dovoljenja, ki jih potrebujejo za opravljanje svojih nalog. Izogibajte se dodeljevanju nepotrebnih dovoljenj.
• Uporaba skupin: Upravljajte dovoljenja prek skupin, namesto da bi dovoljenja dodeljevali neposredno posameznim uporabnikom. To poenostavlja administracijo in zmanjšuje tveganje za napake.
• Redne revizije: Občasno preglejte nastavitve dovoljenj, da zagotovite, da so še vedno ustrezne in da ni dodeljenega nepooblaščenega dostopa.
• Sanitizacija vnosa: Vedno sanitizirajte uporabniški vnos, da preprečite napade z injektiranjem, ki bi lahko obšli vaš sistem dovoljenj.
• Temeljito testiranje: Temeljito preizkusite svoj sistem dovoljenj, da zagotovite, da se obnaša, kot je pričakovano, in da ni ranljivosti. Napišite avtomatizirane teste za preverjanje dovoljenj.
• Bodite na tekočem: Redno posodabljajte svoje ogrodje Django in povezane knjižnice, da izkoristite najnovejše varnostne popravke in popravke napak.
• Razmislite o politiki varnosti vsebine (CSP): CSP lahko pomaga preprečiti napade skriptiranja med spletnimi mesti (XSS), ki se lahko uporabijo za obid avtorizacijskih mehanizmov.

Upoštevanja internacionalizacije

Pri načrtovanju sistema dovoljenj za globalno občinstvo upoštevajte naslednje vidike internacionalizacije:

• Imena vlog: Če vaša aplikacija uporablja vloge (npr. urednik, avtor, moderator), poskrbite, da so imena vlog enostavno prevedljiva in kulturno primerna za vse podprte jezike. Razmislite o uporabi jezikovno specifičnih različic imen vlog.
• Uporabniški vmesnik: Zasnovajte uporabniški vmesnik tako, da bo prilagodljiv različnim jezikom in kulturnim konvencijam. To vključuje formate datuma/časa, formate števil in smer besedila.
• Časovni pasovi: Upoštevajte različne časovne pasove pri podeljevanju ali preklicu dovoljenj na podlagi časovno občutljivih dogodkov. Časovne žige shranite v UTC in jih pretvorite v lokalni časovni pas uporabnika za prikaz.
• Predpisi o zasebnosti podatkov: Zavedajte se predpisov o zasebnosti podatkov v različnih državah (npr. GDPR v Evropi, CCPA v Kaliforniji). Implementirajte ustrezne mehanizme za privolitev in ukrepe za varovanje podatkov.
• Dostopnost: Zagotovite, da je vaš sistem dovoljenj dostopen uporabnikom z invalidnostmi, in se držite standardov dostopnosti, kot je WCAG.

Zaključek

Djangov sistem dovoljenj ponuja zmogljiv in prilagodljiv okvir za upravljanje avtorizacije v vaših spletnih aplikacijah. Z razumevanjem vgrajenih funkcij, dovoljenj po meri, dovoljenj na ravni objekta in najboljših varnostnih praks lahko zgradite varne in razširljive aplikacije, ki ščitijo vaše dragocene vire. Ne pozabite prilagoditi sistema dovoljenj specifičnim potrebam vaše aplikacije ter redno pregledujte in posodabljajte svoje nastavitve, da zagotovite njihovo učinkovitost.

Ta vodnik ponuja celovit pregled Djangovega sistema dovoljenj. Ko boste gradili bolj kompleksne aplikacije, se boste morda srečali z naprednejšimi scenariji. Ne oklevajte in raziščite Djangovo dokumentacijo ter vire skupnosti za nadaljnje smernice.